{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "4c1eee3b-f179-480f-ae47-d5e755eb01fa",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Obtaining file:///dss/dsshome1/04/di93zer/git/cellnet\n",
      "  Preparing metadata (setup.py) ... \u001b[?25ldone\n",
      "\u001b[?25hInstalling collected packages: cellnet\n",
      "  Running setup.py develop for cellnet\n",
      "Successfully installed cellnet\n",
      "\n",
      "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m A new release of pip is available: \u001b[0m\u001b[31;49m23.1.1\u001b[0m\u001b[39;49m -> \u001b[0m\u001b[32;49m23.2.1\u001b[0m\n",
      "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m To update, run: \u001b[0m\u001b[32;49mpython3 -m pip install --upgrade pip\u001b[0m\n"
     ]
    }
   ],
   "source": [
    "!pip install -e /dss/dsshome1/04/di93zer/git/cellnet --no-deps"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e5d5f16a-0644-485f-bc41-47515f0102e1",
   "metadata": {},
   "outputs": [],
   "source": [
    "!pip install celltypist==1.5.3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "b5233885-5ceb-455e-97f1-b8370cceaa2f",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.8/dist-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
      "  from .autonotebook import tqdm as notebook_tqdm\n",
      "/usr/local/lib/python3.8/dist-packages/merlin/dtypes/mappings/tf.py:52: UserWarning: Tensorflow dtype mappings did not load successfully due to an error: No module named 'tensorflow'\n",
      "  warn(f\"Tensorflow dtype mappings did not load successfully due to an error: {exc.msg}\")\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import re\n",
    "import gc\n",
    "from os.path import join\n",
    "\n",
    "import anndata\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import xgboost as xgb\n",
    "import dask.dataframe as dd\n",
    "import pandas as pd\n",
    "import lightning.pytorch as pl\n",
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from scipy.sparse import csr_matrix\n",
    "from sklearn.metrics import classification_report\n",
    "from cellnet.estimators import EstimatorCellTypeClassifier\n",
    "from cellnet.models import TabnetClassifier, LinearClassifier, MLPClassifier\n",
    "from utils import correct_labels, get_best_ckpts, macro_f1_per_group, BIONETWORK_GROUPING"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2de6e8f5-c21c-4b3d-a070-f60e6286a48c",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "489e8d83-86bc-470b-94db-6362d5bef782",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def get_count_matrix(ddf):\n",
    "    x = (\n",
    "        ddf['X']\n",
    "        .map_partitions(\n",
    "            lambda xx: pd.DataFrame(np.vstack(xx.tolist())), \n",
    "            meta={col: 'f4' for col in range(19331)}\n",
    "        )\n",
    "        .to_dask_array(lengths=[1024] * ddf.npartitions)\n",
    "    )\n",
    "    \n",
    "    return x\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "32eb687b-0edc-4b1d-a605-7a17fa8482da",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def eval_tabnet(ckpts, data_path):\n",
    "    estim = EstimatorCellTypeClassifier(data_path)\n",
    "    estim.init_datamodule(batch_size=2048)\n",
    "    estim.trainer = pl.Trainer(logger=[], accelerator='gpu', devices=1)\n",
    "\n",
    "    preds = []\n",
    "    for ckpt in ckpts:\n",
    "        estim.model = TabnetClassifier.load_from_checkpoint(ckpt, **estim.get_fixed_model_params('tabnet'))\n",
    "        probas = estim.predict(estim.datamodule.test_dataloader())\n",
    "        preds.append(np.argmax(probas, axis=1))\n",
    "        gc.collect()\n",
    "\n",
    "    return preds\n",
    "\n",
    "\n",
    "def eval_linear(ckpts, data_path):\n",
    "    estim = EstimatorCellTypeClassifier(data_path)\n",
    "    estim.init_datamodule(batch_size=2048)\n",
    "    estim.trainer = pl.Trainer(logger=[], accelerator='gpu', devices=1)\n",
    "\n",
    "    preds = []\n",
    "    for ckpt in ckpts:\n",
    "        estim.model = LinearClassifier.load_from_checkpoint(ckpt, **estim.get_fixed_model_params('linear'))\n",
    "        probas = estim.predict(estim.datamodule.test_dataloader())\n",
    "        preds.append(np.argmax(probas, axis=1))\n",
    "        gc.collect()\n",
    "\n",
    "    return preds\n",
    "\n",
    "\n",
    "def eval_xgboost(ckpts, data_path):\n",
    "    x_test = np.load(join(data_path, 'pca/x_pca_training_test_split_256.npy'))\n",
    "    \n",
    "    preds = []\n",
    "    for ckpt in ckpts:\n",
    "        clf = xgb.XGBClassifier()\n",
    "        clf.load_model(ckpt)\n",
    "        clf.set_params(predictor='gpu_predictor')\n",
    "        preds.append(clf.predict(x_test))\n",
    "\n",
    "    return preds\n",
    "\n",
    "\n",
    "def eval_mlp(ckpts, data_path):\n",
    "    estim = EstimatorCellTypeClassifier(data_path)\n",
    "    estim.init_datamodule(batch_size=2048)\n",
    "    estim.trainer = pl.Trainer(logger=[], accelerator='gpu', devices=1)\n",
    "\n",
    "    preds = []\n",
    "    for ckpt in ckpts:\n",
    "        estim.model = MLPClassifier.load_from_checkpoint(ckpt, **estim.get_fixed_model_params('mlp'))\n",
    "        probas = estim.predict(estim.datamodule.test_dataloader())\n",
    "        preds.append(np.argmax(probas, axis=1))\n",
    "        gc.collect()\n",
    "\n",
    "    return preds\n",
    "\n",
    "\n",
    "def eval_celltypist(ckpts, data_path):\n",
    "    import celltypist\n",
    "    \n",
    "    ddf = dd.read_parquet(join(data_path, 'test'), split_row_groups=True)\n",
    "    x = get_count_matrix(ddf)\n",
    "    var = pd.read_parquet(join(data_path, 'var.parquet'))\n",
    "\n",
    "    preds = []\n",
    "    for ckpt in ckpts:\n",
    "        preds_ckpt = []\n",
    "        # run this in batches to keep the memory footprint in check\n",
    "        for i, idxs in enumerate(np.array_split(np.arange(x.shape[0]), 20)):\n",
    "            # data is already normalized\n",
    "            adata_test = anndata.AnnData(\n",
    "                X=x[idxs, :].map_blocks(csr_matrix).compute(), \n",
    "                var=var.set_index('feature_name')\n",
    "            )\n",
    "            preds_ckpt.append(celltypist.annotate(adata_test, model=ckpt))\n",
    "\n",
    "        preds.append(\n",
    "            np.concatenate([batch.predicted_labels.to_numpy().flatten() for batch in preds_ckpt])\n",
    "        )\n",
    "\n",
    "    return preds\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e527a9dc-8538-4868-afaf-96e8992e4ca4",
   "metadata": {
    "tags": []
   },
   "source": [
    "# Evaluate performance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "cc1a1313-945d-4c5a-98ea-25210da899e3",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "DATA_PATH = '/mnt/dssmcmlfs01/merlin_cxg_2023_05_15_sf-log1p'\n",
    "\n",
    "LOGS_TABNET = '/mnt/dssfs02/tb_logs/cxg_2023_05_15_tabnet/default'\n",
    "LOGS_LINEAR = '/mnt/dssfs02/tb_logs/juwles/cxg_2023_05_15_linear/default'\n",
    "LOGS_XGBOOST = '/mnt/dssfs02/tb_logs/cxg_2023_05_15_xgboost'\n",
    "LOGS_MLP = '/mnt/dssfs02/tb_logs/cxg_2023_05_15_mlp/default'\n",
    "LOGS_CELLTYPIST = '/mnt/dssfs02/tb_logs/cxg_2023_05_15_celltypist'\n",
    "\n",
    "\n",
    "CKPTS = {\n",
    "    'xgboost': [join(LOGS_XGBOOST, f'version_20_{i}.json') for i in range(1, 6)],\n",
    "    'xgboost_default': [join(LOGS_XGBOOST, f'default_params_{i}.json') for i in range(1, 5)],\n",
    "    'tabnet': get_best_ckpts(LOGS_TABNET, [f'w_augment_{i}' for i in range(1, 6)]),\n",
    "    'linear': get_best_ckpts(LOGS_LINEAR, [f'version_{i}' for i in range(1, 5)]),\n",
    "    'MLP': get_best_ckpts(LOGS_MLP, [f'version_{i}' for i in range(3, 8)]),\n",
    "    'celltypist': [join(LOGS_CELLTYPIST, f'model_1500000_cells_run{i}.pkl') for i in range(1, 5)],\n",
    "    'celltypist_default': [join(LOGS_CELLTYPIST, f'model_1000000_cells_with_mean_run{i}.pkl') for i in range(1, 5)]\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "ff97fd35-2255-47a4-a41c-4092862a1e90",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "cell_type_hierarchy = np.load(join(DATA_PATH, 'cell_type_hierarchy/child_matrix.npy'))\n",
    "y_true = dd.read_parquet(join(DATA_PATH, 'test'), columns='cell_type').compute().to_numpy()\n",
    "tissue_general_mapping = pd.read_parquet(join(DATA_PATH, 'categorical_lookup/tissue_general.parquet'))\n",
    "tissue_general = dd.read_parquet(join(DATA_PATH, 'test'), columns='tissue_general').compute().to_numpy()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d7e81359-7142-4313-a601-5897daccb8e6",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Overall"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "613bc3e8-33bf-489a-a9c4-d33e55a72eaa",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "res = pd.read_csv('model_eval_cache/model_comparision.csv', index_col=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "9830a24c-f2b4-4f9c-8d54-4b80854fffee",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "results = {'f1-score (macro avg.)': [], 'model': [], 'run': []}\n",
    "\n",
    "\n",
    "for model, ckpts in CKPTS.items():\n",
    "    if model not in res.model.tolist():\n",
    "        if model == 'tabnet':\n",
    "            preds = eval_tabnet(ckpts, DATA_PATH)\n",
    "        elif model == 'linear':\n",
    "            preds = eval_linear(ckpts, DATA_PATH)\n",
    "        elif model == 'xgboost':\n",
    "            preds = eval_xgboost(ckpts, DATA_PATH)\n",
    "        elif model == 'xgboost_default':\n",
    "            preds = eval_xgboost(ckpts, DATA_PATH)\n",
    "        elif model == 'MLP':\n",
    "            preds = eval_mlp(ckpts, DATA_PATH)\n",
    "        elif model == 'celltypist':\n",
    "            preds = eval_celltypist(ckpts, DATA_PATH)\n",
    "        elif model == 'celltypist_default':\n",
    "            preds = eval_celltypist(ckpts, DATA_PATH)\n",
    "        else:\n",
    "            raise ValueError\n",
    "\n",
    "        for run, y_pred in enumerate(preds):\n",
    "            y_pred_corr = correct_labels(y_true, y_pred, cell_type_hierarchy)\n",
    "            clf_report = pd.DataFrame(classification_report(y_true, y_pred_corr, output_dict=True)).T\n",
    "            results['f1-score (macro avg.)'].append(clf_report.loc['macro avg', 'f1-score'])\n",
    "            results['model'].append(model)\n",
    "            results['run'].append(f'{model}_run{run}')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "e53dcde6-81af-4ba6-9931-5c1604be8411",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "res = pd.concat([res, pd.DataFrame(results)]).reset_index(drop=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1e490fb3-d4b3-45c0-8fa7-69f2e141a2d8",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "res.to_csv('model_eval_cache/model_comparision.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "43f52bff-d5c6-47a7-b45b-7aa6f28d0c62",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>mean</th>\n",
       "      <th>std</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>model</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>MLP</th>\n",
       "      <td>0.7971</td>\n",
       "      <td>0.0012</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>celltypist</th>\n",
       "      <td>0.7304</td>\n",
       "      <td>0.0015</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>celltypist_default</th>\n",
       "      <td>0.6258</td>\n",
       "      <td>0.0036</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>linear</th>\n",
       "      <td>0.7848</td>\n",
       "      <td>0.0001</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>tabnet</th>\n",
       "      <td>0.8295</td>\n",
       "      <td>0.0007</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>xgboost</th>\n",
       "      <td>0.8127</td>\n",
       "      <td>0.0005</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>xgboost_default</th>\n",
       "      <td>0.5855</td>\n",
       "      <td>0.0112</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                      mean     std\n",
       "model                             \n",
       "MLP                 0.7971  0.0012\n",
       "celltypist          0.7304  0.0015\n",
       "celltypist_default  0.6258  0.0036\n",
       "linear              0.7848  0.0001\n",
       "tabnet              0.8295  0.0007\n",
       "xgboost             0.8127  0.0005\n",
       "xgboost_default     0.5855  0.0112"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(\n",
    "    res\n",
    "    .groupby('model')['f1-score (macro avg.)']\n",
    "    .aggregate(['mean', 'std'])\n",
    "    .applymap(\"{0:.4f}\".format)\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "f30b22fc-7f36-4520-9af5-f135abfe5dfa",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>mean</th>\n",
       "      <th>var</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>model</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>linear</th>\n",
       "      <td>0.78483384</td>\n",
       "      <td>0.00000002</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>tabnet</th>\n",
       "      <td>0.82949732</td>\n",
       "      <td>0.00000055</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "              mean         var\n",
       "model                         \n",
       "linear  0.78483384  0.00000002\n",
       "tabnet  0.82949732  0.00000055"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(\n",
    "    res[res.model.isin(['linear', 'tabnet'])]\n",
    "    .groupby('model')['f1-score (macro avg.)']\n",
    "    .aggregate(['mean', 'var'])\n",
    "    .applymap(\"{0:.8f}\".format)\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "0b860740-2037-4075-9bfd-144f9d137948",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'0.0447±0.0008'"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f'{0.82949732 - 0.78483384:.4f}±{(0.00000055 + 0.00000002)**0.5:.4f}'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f2f986ad-677a-4bb4-b180-a28412622684",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "171af6e5-56a5-4072-b777-8a9b76ee44dc",
   "metadata": {
    "tags": []
   },
   "source": [
    "# Plot model comparision"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "56a1c2de-5d1f-4f72-8dfc-1e20a45a29c0",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "403970d9-9944-4175-8930-c7d3facbacb3",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>f1-score (macro avg.)</th>\n",
       "      <th>model</th>\n",
       "      <th>run</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.812979</td>\n",
       "      <td>xgboost</td>\n",
       "      <td>xgboost_run0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11</th>\n",
       "      <td>0.784953</td>\n",
       "      <td>linear</td>\n",
       "      <td>linear_run1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>19</th>\n",
       "      <td>0.575692</td>\n",
       "      <td>xgboost_default</td>\n",
       "      <td>xgboost_default_run0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.813049</td>\n",
       "      <td>xgboost</td>\n",
       "      <td>xgboost_run1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>28</th>\n",
       "      <td>0.627432</td>\n",
       "      <td>celltypist_default</td>\n",
       "      <td>celltypist_default_run1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    f1-score (macro avg.)               model                      run\n",
       "0                0.812979             xgboost             xgboost_run0\n",
       "11               0.784953              linear              linear_run1\n",
       "19               0.575692     xgboost_default     xgboost_default_run0\n",
       "1                0.813049             xgboost             xgboost_run1\n",
       "28               0.627432  celltypist_default  celltypist_default_run1"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model_comparision_df = pd.read_csv('model_eval_cache/model_comparision.csv', index_col=0)\n",
    "model_comparision_df[~model_comparision_df.model.isin(['xgboost_default', 'celltypist_default'])]\n",
    "model_comparision_df.sample(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "e70bb3ac-8258-46d6-9e71-073193e03217",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 610x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(1, 1, figsize=(6.1, 4))\n",
    "\n",
    "ax = sns.barplot(\n",
    "    x='model',\n",
    "    y='f1-score (macro avg.)',\n",
    "    order=['celltypist', 'linear', 'tabnet', 'xgboost', 'MLP'],\n",
    "    errorbar='sd',\n",
    "    palette=['#9467bd', '#1f77b4', '#ff7f0e', '#ff7f0e', '#ff7f0e'],\n",
    "    data=model_comparision_df\n",
    ")\n",
    "ax.set_ylabel('F1-Score (macro avg.)')\n",
    "ax.set_xlabel('')\n",
    "ax.set_xticklabels(['CellTypist', 'linear (ours)', 'scTab', 'XGBoost', 'MLP'])\n",
    "ax.set_ylim(0., 1.)\n",
    "\n",
    "\n",
    "for p in ax.patches:\n",
    "    ax.annotate(format(p.get_height(), '.2f'), \n",
    "                (p.get_x() + p.get_width() / 2., p.get_height()), \n",
    "                ha = 'center', va = 'center', \n",
    "                xytext = (0, 9), \n",
    "                textcoords = 'offset points')\n",
    "\n",
    "\n",
    "fs = 6.5\n",
    "ax.annotate('Nonlinear model', xy=(0.7, 1.45), xytext=(0.7, 1.55), xycoords='axes fraction', \n",
    "            fontsize=fs*1.5, ha='center', va='bottom',\n",
    "            bbox=dict(boxstyle='square', fc='white', color='k'),\n",
    "            arrowprops=dict(arrowstyle='-[, widthB=9., lengthB=1.', lw=1.5, color='k'))\n",
    "\n",
    "ax.annotate('More training data', xy=(0.6, 1.1), xytext=(0.6, 1.2), xycoords='axes fraction', \n",
    "            fontsize=fs*1.5, ha='center', va='bottom',\n",
    "            bbox=dict(boxstyle='square', fc='white', color='k'),\n",
    "            arrowprops=dict(arrowstyle='-[, widthB=12.8, lengthB=1.', lw=1.5, color='k'))\n",
    "\n",
    "ax.annotate('Reference\\nmodel', xy=(0.1, 1.1), xytext=(0.1, 1.2), xycoords='axes fraction', \n",
    "            fontsize=fs*1.5, ha='center', va='bottom',\n",
    "            bbox=dict(boxstyle='square', fc='white', color='k'),\n",
    "            arrowprops=dict(arrowstyle='-[, widthB=2., lengthB=1.', lw=1.5, color='k'))\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.savefig('/dss/dsshome1/04/di93zer/git/cellnet/figure-plots/figure1/model-comparision.pdf')\n",
    "plt.savefig('/dss/dsshome1/04/di93zer/git/cellnet/figure-plots/figure1/model-comparision.png', dpi=300)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1c5526d0-0b06-4e04-be91-d376182ce4d6",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "ceceb461-dfc9-494d-87e8-0daa85d0715d",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Grouped by bionetwork"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "0374854f-acdc-4434-8879-1568fb34bd70",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# only do this for TabNet + Linear model for now"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2f4abb35-8425-4131-befb-b6fc2339d55f",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "preds_tabnet = eval_tabnet(\n",
    "    get_best_ckpts(LOGS_TABNET, [f'w_augment_{i}' for i in range(1, 6)]), DATA_PATH\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fd53c34c-bb97-46a4-a1f2-fecc4cdfc440",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "preds_linear = eval_linear(\n",
    "    get_best_ckpts(LOGS_LINEAR, [f'version_{i}' for i in range(1, 5)]), DATA_PATH\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "37e8dc27-5784-40ad-af79-31dbbbd0309d",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "tissue = tissue_general_mapping.loc[tissue_general].to_numpy().flatten()\n",
    "res = {'f1-score (macro avg.)': [], 'bionetwork': [], 'run': [], 'model': []}\n",
    "\n",
    "\n",
    "for model, preds in [('TabNet', preds_tabnet), ('Linear', preds_linear)]:\n",
    "    for i, y_pred in enumerate(preds):\n",
    "        y_pred_corr = correct_labels(y_true, y_pred, cell_type_hierarchy)\n",
    "        f1_score_per_bionetwork = macro_f1_per_group(y_true, y_pred, tissue, BIONETWORK_GROUPING)\n",
    "        res['f1-score (macro avg.)'] += f1_score_per_bionetwork.f1_score.tolist()\n",
    "        res['bionetwork'] += f1_score_per_bionetwork.group.tolist()\n",
    "        res['run'] += [f'run{i}'] * len(f1_score_per_bionetwork)\n",
    "        res['model'] += [model] * len(f1_score_per_bionetwork)\n",
    "        gc.collect()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "c7c570f2-5fdc-4901-8f8c-01aff8448a60",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "df = pd.DataFrame(res)\n",
    "df.to_csv('model_eval_cache/linear_vs_tabnet_per_organ.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "d5cdfa1c-f36e-4a2e-bfc8-3fd3ab2d620c",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "shortend_bionetworks = {\n",
    "    'oral and craniofacial': 'craniofacial\\noral',\n",
    "    'blood and immune': 'blood\\nimmune',\n",
    "    'nervous system': 'nervous\\nsystem',\n",
    "    'musculoskeletal': 'musculo\\nskeletal',\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "d67e705b-da57-4230-ab1d-084b695f7448",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 610x300 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(1, 1, figsize=(6.1, 3.))\n",
    "\n",
    "df = pd.read_csv('model_eval_cache/linear_vs_tabnet_per_organ.csv', index_col=0)\n",
    "df['bionetwork'] = (\n",
    "    df['bionetwork']\n",
    "    .str.replace('_', ' ')\n",
    "    .replace(shortend_bionetworks)\n",
    ")\n",
    "df['model'] = df.model.replace({'TabNet': 'scTab', 'Linear': 'linear'})\n",
    "ax = sns.barplot(\n",
    "    x='bionetwork',\n",
    "    y='f1-score (macro avg.)',\n",
    "    hue='model',\n",
    "    hue_order=['linear', 'scTab'],\n",
    "    data=df[df.bionetwork != 'adipose'],\n",
    "    ax=ax,\n",
    ")\n",
    "ax.set_xlabel('')\n",
    "ax.set_ylabel('F1-score (macro avg.)')\n",
    "ax.tick_params(axis='x', labelrotation=70)\n",
    "ax.legend(title='')\n",
    "ax.set_ylim(0., 1.)\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.savefig('/dss/dsshome1/04/di93zer/git/cellnet/figure-plots/figure1/organ_wise_performance.pdf')\n",
    "plt.savefig('/dss/dsshome1/04/di93zer/git/cellnet/figure-plots/figure1/organ_wise_performance.png', dpi=300)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9d78e5dc-d26e-46be-bdde-5686747d8e7e",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "12c6474f-2fb0-4199-870b-892f0f324473",
   "metadata": {
    "tags": []
   },
   "source": [
    "# Lung only vs cross organ model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "2aa03fef-b9ed-41fc-bdc1-c423bf9928b7",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "from statistics import mean, stdev\n",
    "from scipy.stats import ttest_ind"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "63399759-57b4-4324-8bb3-d12c8825dd6f",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "DATA_PATH = '/mnt/dssmcmlfs01/merlin_cxg_2023_05_15_sf-log1p_lung_only'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "71334750-49de-4a75-970a-070b2f43b8e7",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "cell_type_hierarchy = np.load(join(DATA_PATH, 'cell_type_hierarchy/child_matrix.npy'))\n",
    "y_true = dd.read_parquet(join(DATA_PATH, 'test'), columns='cell_type').compute().to_numpy()\n",
    "tissue_general_mapping = pd.read_parquet(join(DATA_PATH, 'categorical_lookup/tissue_general.parquet'))\n",
    "tissue_general = dd.read_parquet(join(DATA_PATH, 'test'), columns='tissue_general').compute().to_numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "53a86396-81a9-4d8e-927d-b9ebdfd5c9ff",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "LOGS_CROSS_ORGAN = '/mnt/dssfs02/tb_logs/cxg_2023_05_15_tabnet/default'\n",
    "LOGS_LUNG_ONLY = '/mnt/dssfs02/tb_logs/cxg_2023_05_15_lung_only_tabnet/default'\n",
    "LOGS_CROSS_ORGAN_LINEAR = '/mnt/dssfs02/tb_logs/cxg_2023_05_15_linear/default'\n",
    "LOGS_LUNG_ONLY_LINEAR = '/mnt/dssfs02/tb_logs/cxg_2023_05_15_lung_only_linear/default'\n",
    "\n",
    "ckpts_cross_organ = get_best_ckpts(LOGS_CROSS_ORGAN, [f'no_augment_{i}' for i in range(1, 6)])\n",
    "ckpts_lung_only = get_best_ckpts(LOGS_LUNG_ONLY, [f'no_augment_{i}' for i in range(1, 6)])\n",
    "ckpts_cross_organ_linear = get_best_ckpts(LOGS_CROSS_ORGAN_LINEAR, [f'version_{i}' for i in range(1, 5)])\n",
    "ckpts_lung_only_linear = get_best_ckpts(LOGS_LUNG_ONLY_LINEAR, [f'version_{i}' for i in range(1, 6)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "d71319ed-fc29-4502-84ba-c81f25ef57ee",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "GPU available: True (cuda), used: True\n",
      "TPU available: False, using: 0 TPU cores\n",
      "IPU available: False, using: 0 IPUs\n",
      "HPU available: False, using: 0 HPUs\n",
      "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n",
      "SLURM auto-requeueing enabled. Setting signal handlers.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Predicting DataLoader 0: 100%|██████████| 173/173 [01:06<00:00,  2.59it/s]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n",
      "SLURM auto-requeueing enabled. Setting signal handlers.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Predicting DataLoader 0: 100%|██████████| 173/173 [01:03<00:00,  2.74it/s]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n",
      "SLURM auto-requeueing enabled. Setting signal handlers.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Predicting DataLoader 0: 100%|██████████| 173/173 [01:02<00:00,  2.77it/s]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n",
      "SLURM auto-requeueing enabled. Setting signal handlers.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Predicting DataLoader 0: 100%|██████████| 173/173 [01:01<00:00,  2.80it/s]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n",
      "SLURM auto-requeueing enabled. Setting signal handlers.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Predicting DataLoader 0: 100%|██████████| 173/173 [01:00<00:00,  2.86it/s]\n"
     ]
    }
   ],
   "source": [
    "preds_cross_organ = eval_tabnet(ckpts_cross_organ, DATA_PATH)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "1f0b6c20-b897-48d6-9ccb-00f80a7e74f1",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "GPU available: True (cuda), used: True\n",
      "TPU available: False, using: 0 TPU cores\n",
      "IPU available: False, using: 0 IPUs\n",
      "HPU available: False, using: 0 HPUs\n",
      "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n",
      "SLURM auto-requeueing enabled. Setting signal handlers.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Predicting DataLoader 0: 100%|██████████| 173/173 [00:24<00:00,  7.16it/s]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n",
      "SLURM auto-requeueing enabled. Setting signal handlers.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Predicting DataLoader 0: 100%|██████████| 173/173 [00:24<00:00,  7.02it/s]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n",
      "SLURM auto-requeueing enabled. Setting signal handlers.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Predicting DataLoader 0: 100%|██████████| 173/173 [00:24<00:00,  7.00it/s]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n",
      "SLURM auto-requeueing enabled. Setting signal handlers.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Predicting DataLoader 0: 100%|██████████| 173/173 [00:23<00:00,  7.48it/s]\n"
     ]
    }
   ],
   "source": [
    "preds_cross_organ_linear = eval_linear(ckpts_cross_organ_linear, DATA_PATH)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "26214f3d-9efb-4656-9c9a-55ba403193aa",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "GPU available: True (cuda), used: True\n",
      "TPU available: False, using: 0 TPU cores\n",
      "IPU available: False, using: 0 IPUs\n",
      "HPU available: False, using: 0 HPUs\n",
      "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n",
      "SLURM auto-requeueing enabled. Setting signal handlers.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Predicting DataLoader 0: 100%|██████████| 173/173 [00:56<00:00,  3.06it/s]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n",
      "SLURM auto-requeueing enabled. Setting signal handlers.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Predicting DataLoader 0: 100%|██████████| 173/173 [00:59<00:00,  2.89it/s]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n",
      "SLURM auto-requeueing enabled. Setting signal handlers.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Predicting DataLoader 0: 100%|██████████| 173/173 [00:57<00:00,  3.00it/s]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n",
      "SLURM auto-requeueing enabled. Setting signal handlers.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Predicting DataLoader 0: 100%|██████████| 173/173 [00:58<00:00,  2.98it/s]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n",
      "SLURM auto-requeueing enabled. Setting signal handlers.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Predicting DataLoader 0: 100%|██████████| 173/173 [00:58<00:00,  2.98it/s]\n"
     ]
    }
   ],
   "source": [
    "preds_lung_only = eval_tabnet(ckpts_lung_only, DATA_PATH)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "d07bb50c-bdb5-4939-821f-68c37cd93464",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "GPU available: True (cuda), used: True\n",
      "TPU available: False, using: 0 TPU cores\n",
      "IPU available: False, using: 0 IPUs\n",
      "HPU available: False, using: 0 HPUs\n",
      "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n",
      "SLURM auto-requeueing enabled. Setting signal handlers.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Predicting DataLoader 0: 100%|██████████| 173/173 [00:23<00:00,  7.42it/s]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n",
      "SLURM auto-requeueing enabled. Setting signal handlers.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Predicting DataLoader 0: 100%|██████████| 173/173 [00:24<00:00,  7.15it/s]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n",
      "SLURM auto-requeueing enabled. Setting signal handlers.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Predicting DataLoader 0: 100%|██████████| 173/173 [00:25<00:00,  6.80it/s]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n",
      "SLURM auto-requeueing enabled. Setting signal handlers.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Predicting DataLoader 0: 100%|██████████| 173/173 [00:25<00:00,  6.77it/s]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n",
      "SLURM auto-requeueing enabled. Setting signal handlers.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Predicting DataLoader 0: 100%|██████████| 173/173 [00:25<00:00,  6.74it/s]\n"
     ]
    }
   ],
   "source": [
    "preds_lung_only_linear = eval_linear(ckpts_lung_only_linear, DATA_PATH)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "fc449c35-a686-4703-ac84-8b5b53bc1205",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.7062 +/- 0.0122\n"
     ]
    }
   ],
   "source": [
    "f1_scores_cross_organ = []\n",
    "\n",
    "for y_pred in preds_cross_organ:\n",
    "    y_pred_corr = correct_labels(y_true, y_pred, cell_type_hierarchy)\n",
    "    f1_scores_cross_organ.append(\n",
    "        float(pd.DataFrame(classification_report(\n",
    "            y_true, \n",
    "            y_pred_corr, \n",
    "            labels=np.unique(y_true),\n",
    "            zero_division=0.,\n",
    "            output_dict=True\n",
    "        )).T.loc['macro avg', 'f1-score'])\n",
    "    )\n",
    "\n",
    "print(f'{mean(f1_scores_cross_organ):.4f} +/- {stdev(f1_scores_cross_organ):.4f}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "438f5ff7-aeda-48d4-9758-014764d61c6f",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.5291 +/- 0.0041\n"
     ]
    }
   ],
   "source": [
    "f1_scores_cross_organ_linear = []\n",
    "\n",
    "for y_pred in preds_cross_organ_linear:\n",
    "    y_pred_corr = correct_labels(y_true, y_pred, cell_type_hierarchy)\n",
    "    f1_scores_cross_organ_linear.append(\n",
    "        float(pd.DataFrame(classification_report(\n",
    "            y_true, \n",
    "            y_pred_corr, \n",
    "            labels=np.unique(y_true),\n",
    "            zero_division=0.,\n",
    "            output_dict=True\n",
    "        )).T.loc['macro avg', 'f1-score'])\n",
    "    )\n",
    "\n",
    "print(f'{mean(f1_scores_cross_organ_linear):.4f} +/- {stdev(f1_scores_cross_organ_linear):.4f}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "dd1991b0-29f2-4dc0-a6a3-8688d8938982",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.7220 +/- 0.0078\n"
     ]
    }
   ],
   "source": [
    "f1_scores_lung_only = []\n",
    "\n",
    "for y_pred in preds_lung_only:\n",
    "    y_pred_corr = correct_labels(y_true, y_pred, cell_type_hierarchy)\n",
    "    f1_scores_lung_only.append(\n",
    "        float(pd.DataFrame(classification_report(\n",
    "            y_true, \n",
    "            y_pred_corr, \n",
    "            labels=np.unique(y_true),\n",
    "            zero_division=0.,\n",
    "            output_dict=True\n",
    "        )).T.loc['macro avg', 'f1-score'])\n",
    "    )\n",
    "\n",
    "print(f'{mean(f1_scores_lung_only):.4f} +/- {stdev(f1_scores_lung_only):.4f}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "cac0476d-2776-4538-8958-73e58ea92d6f",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.7146 +/- 0.0040\n"
     ]
    }
   ],
   "source": [
    "f1_scores_lung_only_linear = []\n",
    "\n",
    "for y_pred in preds_lung_only_linear:\n",
    "    y_pred_corr = correct_labels(y_true, y_pred, cell_type_hierarchy)\n",
    "    f1_scores_lung_only_linear.append(\n",
    "        float(pd.DataFrame(classification_report(\n",
    "            y_true, \n",
    "            y_pred_corr, \n",
    "            labels=np.unique(y_true),\n",
    "            zero_division=0.,\n",
    "            output_dict=True\n",
    "        )).T.loc['macro avg', 'f1-score'])\n",
    "    )\n",
    "\n",
    "print(f'{mean(f1_scores_lung_only_linear):.4f} +/- {stdev(f1_scores_lung_only_linear):.4f}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "169e7d10-3a3f-4842-9be5-007aa4895b19",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "p-value: 0.0403\n"
     ]
    }
   ],
   "source": [
    "print(f'p-value: {ttest_ind(f1_scores_lung_only, f1_scores_cross_organ).pvalue:.4f}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "aa9c6d66-3a69-4877-8516-c3b75ee20339",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 540x270 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "df_cross_organ_vs_lung = pd.DataFrame({\n",
    "    'F1-score (macro avg.)': (\n",
    "        f1_scores_cross_organ + \n",
    "        f1_scores_lung_only + \n",
    "        f1_scores_cross_organ_linear + \n",
    "        f1_scores_lung_only_linear\n",
    "    ),\n",
    "    'training': (\n",
    "        ['cross-organ'] * len(f1_scores_cross_organ) + \n",
    "        ['organ-specfic\\n (lung)'] * len(f1_scores_lung_only) +\n",
    "        ['cross-organ'] * len(f1_scores_cross_organ_linear) + \n",
    "        ['organ-specfic\\n (lung)'] * len(f1_scores_lung_only_linear)\n",
    "    ),\n",
    "    'model': (\n",
    "        ['scTab'] * len(f1_scores_cross_organ) + \n",
    "        ['scTab'] * len(f1_scores_lung_only) +\n",
    "        ['linear'] * len(f1_scores_cross_organ_linear) + \n",
    "        ['linear'] * len(f1_scores_lung_only_linear)\n",
    "    )\n",
    "}).sort_values('training', ascending=False)\n",
    "\n",
    "\n",
    "fig, ax = plt.subplots(1, 1, figsize=[5.4, 2.7])\n",
    "sns.lineplot(\n",
    "    x='training',\n",
    "    y='F1-score (macro avg.)',\n",
    "    hue='model',\n",
    "    hue_order=['linear', 'scTab'],\n",
    "    data=df_cross_organ_vs_lung,\n",
    "    marker='o',\n",
    "    markersize=8,\n",
    "    sort=False,\n",
    "    ax=ax\n",
    ")\n",
    "# ax.set_ylim(0.4, 0.9)\n",
    "ax.set_xlim([-0.2, 1.2])\n",
    "ax.set_xlabel('')\n",
    "ax.set_yticks(np.linspace(0.52, 0.72, 6))\n",
    "ax.legend(title='')\n",
    "ax.set_ylabel('F1-score (macro avg.)\\n lung-specific')\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.savefig('/dss/dsshome1/04/di93zer/git/cellnet/figure-plots/figure2/cross_organ_vs_lung_only.pdf')\n",
    "plt.savefig('/dss/dsshome1/04/di93zer/git/cellnet/figure-plots/figure2/cross_organ_vs_lung_only.png', dpi=300)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f96208c5-fb06-4a29-8a9c-92fd57142b14",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
